package com.clouddong.exterapi.service.impl;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import com.clouddong.exterapi.dao.ProbeListDaoI;
import com.clouddong.exterapi.dao.ProbeXmlDaoI;
import com.clouddong.exterapi.po.ProbeListTablePo;
import com.clouddong.exterapi.po.ProbeTaskXmlPingJoinPo;
import com.clouddong.exterapi.po.ProbeXmlPingListJoinPo;
import com.clouddong.exterapi.service.ProbeOperationServiceI;
import com.clouddong.exterapi.vo.ProbeListTableVo;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;

/**
<blockquote>
<h1></h1>
* @author lpr
* @version 1.0.0
* @date [2018年7月17日 下午1:18:00]
*/
@Service(value="probeOperationServiceImpl")
public class ProbeOperationServiceImpl implements ProbeOperationServiceI
{
	@Autowired
	private ProbeXmlDaoI probeXmlDaoI;
	@Autowired
	private ProbeListDaoI probeListDaoI;
	
	/**   
	 <blockquote>
	 <h1>根据attributeAll提取要返回的字段并获取nf_probe_list表下的所有的该字段信息</h1>
	 * @param attributeAll
	 * @return 
	 * @throws Exception 
	 */
	@Override
	public List<Map<String, Object>> getFinalDataByField(List<String> attributeAll) throws Exception
	{
		List<Map<String, Object>> retList=new ArrayList<>();//定义最终返回的LIst
		//获取数据源
		List<ProbeListTablePo> probeListTablePo =getDataSourceIsOperArea(attributeAll);
		//将数据封装为JSON并返回
		retList=getFinalDataIsOperArea(probeListTablePo);
		return retList;
	}
	/**
	<blockquote>
	<h1>根据传入的List<&ProbeListTablePo>对象封装最终返回的JSON,只负责将JSON封装为指定格式</h1>
	* @version 1.0.0
	* @param poList
	* @return
	 */
	private List<Map<String, Object>> getFinalDataIsOperArea(List<ProbeListTablePo> poList) throws Exception
	{
	    List<Map<String, Object>> retList=new ArrayList<>();//定义最终返回的List
		for(int i=0,len=poList.size();i<len;i++ ){//遍历得到的数据对象
		  ProbeListTablePo p=poList.get(i);
		  Map<String,Object> areaJson=new LinkedHashMap<>();//定义单个省得区域JSON
		  String province=p.getProbe_province();//获取省份
		  String city=p.getProbe_city();//获取地市
		  String probeId=p.getProbe_id();//获取探针ID
		  //根据传入的最终返回的List和省份判断其中的JSON元素是否包含该省份，返回-1则不包含
		  Integer index=isAreaByProvince(retList,province);
		  if(index>-1)
		  {//判断整体集合中是否包含该省份
			 //取到List对应位的数据
			  areaJson=retList.get(index);
			  //获取地市key对应的value
			  List<Map<String, String>> keysList= (List<Map<String, String>>) areaJson.get(CITY_AREANAME_KEY);
			  //将地市JSON添加入List
			  keysList.add(getOneCityJsonIsOperArea(city, probeId));
			  //将添加完地市的List放入地市key对应的value
			  areaJson.put(CITY_AREANAME_KEY, keysList);
			  //将List对应位修改为添加地市后的JSON
			  retList.set(index, areaJson);
		  }else {
			  List<Map<String,String>> cityAll=new ArrayList<>();//地市的集合
			  if(!province.equals(city))
			  {//判断地市名称是否和省份名称不相同
				  cityAll.add(getOneCityJsonIsOperArea(city,probeId));
			  }
			  areaJson=getProJsonIsOperArea(province,cityAll);//获得某个省份的区域JSON
			  retList.add(areaJson);//添加入List中
		  }
		}
	  return retList;
	}
	/**
	<blockquote>
	<h1>根据传入的最终返回的List和省份判断其中的JSON元素是否包含该省份</h1>
	* @version 1.0.0
	* @param retList - 最终返回的List
	* @param province - 省份
	* @return - Integer类型的数据如果找到则返回对应的位置，没找到返回-1
	* @throws ClassCastException
	 */
	private Integer isAreaByProvince(List<Map<String, Object>> retList,String province) throws Exception
	{
		Integer index=-1;//定义初始化记位器
		for(int i=0,len=retList.size();i<len;i++)
		{//遍历传入的List
			Map<String, Object> mapObject=retList.get(i);//获得该List第i位的数据强转为JSON
			if(mapObject.containsValue(province))
			{//判断该Map中是否包含该省份
				index=i;//将记位器改为i
				break;
			}
		}
		return index;
	}
	/**
	<blockquote>
	<h1>根据传入的字段名获取查询到的List<&ProbeListTablePo>类型的数据</h1>
	* @version 1.0.0
	* @param attributeAll
	* @return
	 */
	@Transactional(readOnly=true,propagation=Propagation.REQUIRED)
	private List<ProbeListTablePo> getDataSourceIsOperArea(List<String> attributeAll)
	{
		List<ProbeListTablePo> retList=probeListDaoI.getProbeListByField(attributeAll);
		
		return retList;
	}
	/**
	<blockquote>
	<h1>封装省份区域接口返回的整体区域JSON</h1>
	* @version 1.0.0
	* @param key - 省份姓名
	* @param value - 地市List
	* @return
	 */
	private Map<String, Object> getProJsonIsOperArea(String province,List<Map<String, String>> ciy)
	{
		Map<String, Object> retJson=new LinkedHashMap<>();
		retJson.put(PRO_AREANAME_KEY, province);
		retJson.put(CITY_AREANAME_KEY, ciy);
		return retJson;
	}
	/**
	<blockquote>
	<h1>封装单个地市区域返回的JSON</h1>
	* @version 1.0.0
	* @return
	*/
	private Map<String, String> getOneCityJsonIsOperArea(String key,String value)
	{
		Map<String, String> retJson=new LinkedHashMap<>();//定义一个JSON临时变量,用来存放地市及其对应状态
		retJson.put(CITY_AREACITYNAME_KEY, key);
		retJson.put(CITY_AREACITYID_KEY, value);
		return retJson;
	}
	/**
	 <blockquote>
	 <h1> </h1>
	 * @param poList
	 * @return
	 * @throws Exception
	 */
	@Override
	public List<List<String>> getFinalDataIsOperPingTable(List<ProbeXmlPingListJoinPo> poList,String typeId) throws Exception
	{
		List<List<String>> retList=new ArrayList<>();//最终返回的List
		
		for(int i=0,len=poList.size();i<len;i++ ){//遍历得到的数据对象
			ProbeXmlPingListJoinPo p=poList.get(i);
			List<String> list=new ArrayList<>();//临时存放元素的List
			list.add(p.getProbe_id());//探针id
			list.add(p.getProbe_province());//省份
			list.add(p.getProbe_city());//地市
			//获取判断后的地市Ping码
			int cityPingCode=ProbeClientServiceImpl.isCityPingCodeIsOper(p.getLost_rate()!=null?Long.valueOf(p.getLost_rate()):0L,typeId);
			list.add(ProbeClientServiceImpl.isCityCodeOutVal(typeId, cityPingCode));//表格中显示的是否Ping通汉字
			list.add(p.getProbe_uptime());//更新时间
			list.add(p.getTask_id().toString());//TaskId
			//将单个的集合添加到总集合中
			retList.add(list);
		}
		return retList;
	}
	/**
	<blockquote>
	<h1>根据传入的List&<&XMLPingListJointPo>对象封装最终返回的JSON,只负责将JSON封装为指定格式</h1>
	* @version 1.0.0
	* @param objList - 传入的List<&ProbeJointTablePo>对象
	* @return
	 */
	@Override
	public Map<String,List<List<Map<String, Object>>>> getFinalDataIsOperPingMap(List<ProbeXmlPingListJoinPo> poList,String type_id)
	{
		Map<String,List<List<Map<String, Object>>>> retMap=new LinkedHashMap<>();//定义最终返回的JSON
		for(int i=0,len=poList.size();i<len;i++ )
		{//遍历得到的数据对象
			    ProbeXmlPingListJoinPo p=poList.get(i);
				List<List<Map<String, Object>>> objAll=new ArrayList<>();//定义一个Object类型的集合用来当作返回的JSON的value
				List<Map<String, Object>> cityAll=new ArrayList<>();
				String provinceKey=p.getProbe_province();//获取省份信息
				Integer lost_rate=p.getLost_rate();
				Integer cityPingCode=ProbeClientServiceImpl.isCityPingCodeIsOper(lost_rate!=null?Long.valueOf(lost_rate):0L,type_id);//获取地市Ping码的实际对应值
				if(retMap.containsKey(provinceKey))
				{//判断Map中是否已经存在该省份
					//获取该省份对应的省份，省份Ping码，地市，地市Ping码对应的value并强制转化为Object集合
					objAll=retMap.get(provinceKey);
					//获取地市信息
					cityAll=objAll.get(1);
					//在原来的我地市基础上添加新的地市
					Map<String, Object> cityMap= getOneCityJsonIsOperTask(p.getProbe_city(), cityPingCode);
					cityAll.add(cityMap);
					objAll.set(1,cityAll);
				}else {//不存在
					//将省份信息写入到集合中
					objAll.add(getProJsonIsOperTask(provinceKey,cityPingCode));
					//将地市信息写入到集合中
					Map<String, Object> cityMap=getOneCityJsonIsOperTask(p.getProbe_city(), cityPingCode);
					cityAll.add(cityMap);
					objAll.add(cityAll);
				}
				retMap.put(provinceKey, objAll);//添加数据
		}
		return retMap;
	}
	/**
	<blockquote>
	<h1>从DAO层查询数据并返回</h1>
	* @version 1.0.0
	* @param task_id
	* @return
	 */
	@Override
	@Transactional(readOnly=true,propagation=Propagation.REQUIRED)
	public List<ProbeXmlPingListJoinPo> getDataSourceIsOperPing(String task_id)
	{
		HashMap<String, Object> map=new HashMap<>();
		map.put("task_id", task_id);
		List<ProbeXmlPingListJoinPo> retList=probeXmlDaoI.getUnionDataToXmlPingList(map);
		return retList;
	}
	/**
	<blockquote>
	<h1>以分页的方式从DAO层查询数据并返回</h1>
	* @version 1.0.0
	* @param task_id
	* @param pageNum - 当前页
	* @param pageSize - 每页几条数据
	* @return
	 */
	@Override
	@Transactional(readOnly=true,propagation=Propagation.REQUIRED)
	public PageInfo<ProbeXmlPingListJoinPo> getPageDataSourceIsOperPingMap(
	        String task_id,String provinceName,Integer pageCount,Integer pageSize,Integer sort,String sortDic)
	{
		HashMap<String, Object> map=new HashMap<>();//定义存放SQL所需数据的MAP
		map.put("task_id", task_id);
		map.put("probe_province", provinceName);
		map.put("sort", sort==null?null:sort);
		map.put("sortDic", sortDic==null?"DESC":sortDic);
		PageHelper.startPage(pageCount==null||pageSize==null?1:(pageCount/pageSize)+1,pageSize==null?Integer.MAX_VALUE:pageSize);
		//执行DAO层的查询
		List<ProbeXmlPingListJoinPo> retList=probeXmlDaoI.getUnionDataToXmlPingList(map);
		PageInfo<ProbeXmlPingListJoinPo> pageInfo=new PageInfo<>(retList);
		return pageInfo;
	}
	/**
	<blockquote>
	<h1>封装省份返回的JSON</h1>
	* @version 1.0.0
	* @param key - JSON的key
	* @param value - JSON的value
	* @return - 封装后的JSON
	 */
	private List<Map<String, Object>> getProJsonIsOperTask(String key,Integer value)
	{
		List<Map<String, Object>> retList=new ArrayList<>();
		Map<String, Object> retJson=new LinkedHashMap<>();//定义一个JSON临时变量,用来存放省份及其对应状态
		retJson.put(PRO_PINGNAME_KEY, key);
		retJson.put(PRO_PINGCODE_KEY, value);
		retList.add(retJson);
		return retList;
	}
	/**
	<blockquote>
	<h1>封装单个地市返回的JSON</h1>
	* @version 1.0.0
	* @return
	 */
	private Map<String, Object> getOneCityJsonIsOperTask(String cityName,Integer cityPing)
	{
		Map<String, Object> retJson=new LinkedHashMap<>();//定义一个JSON临时变量,用来存放地市及其对应状态
		retJson.put(CITY_PINGNAME_KEY, cityName);
		retJson.put(CITY_PINGCODE_KEY, cityPing);
		return retJson;
	}
	/**
	<blockquote>
	<h1>封装分页状态下的单个地市返回的JSON</h1>
	* @version 1.0.0
	* @return
	 */
	private Map<String, Object> getPageOneCityJsonIsOperTask(
			String cityName,Integer cityPing,String probeId,String upTime)
	{
		Map<String, Object> retJson=new LinkedHashMap<>();//定义一个JSON临时变量,用来存放地市及其对应状态
		retJson.put(CITY_PINGNAME_KEY, cityName);
		retJson.put(CITY_PINGCODE_KEY, cityPing);
		retJson.put(CITY_PROBEID_KEY, probeId);
		retJson.put(CITY_UPTIME_KEY, upTime);
		return retJson;
	}
	/**
	<blockquote>
	<h1>将数据源封装为最终的指定的格式并返回</h1>
	* @version 1.0.0
	* @param poList
	* @return
	 */
	@Override
	public List<List<String>> getFinalDataIsOperQuery(List<ProbeListTablePo> poList)
	{
		List<List<String>> retList=new ArrayList<>();//最终返回的List
		
		for(int i=0,len=poList.size();i<len;i++ ){//遍历得到的数据对象
			ProbeListTablePo p=poList.get(i);
			List<String> list=new ArrayList<>();//临时存放元素的List
			list.add(p.getProbe_id());
			list.add(p.getProbe_name());
			list.add(p.getProbe_province());
			list.add(p.getProbe_city());
			list.add(p.getProbe_uptime());
			//将单个的集合添加到总集合中
			retList.add(list);
		}
		return retList;
	}
	/**
	<blockquote>
	<h1>获取关于运维的查询功能数据源</h1>
	* @version 1.0.0
	* @param proListTableVo
	* @return
	 */
	@Override
	@Transactional(readOnly=true,propagation=Propagation.REQUIRED)
	public List<ProbeListTablePo> getDataSourceIsOperQuery(ProbeListTableVo proListTableVo)
	{
		HashMap<String, Object> map=new HashMap<>();//定义存放SQL所需数据的MAP
		map.put("proListTableVo", proListTableVo);
		List<ProbeListTablePo> poList=probeListDaoI.getProbeListByIdCityIsLink(map);
		return poList;
	}
	
	@Override
	@Transactional(readOnly=true,propagation=Propagation.REQUIRED)
	public PageInfo<ProbeListTablePo> getPageDataSourceIsOperQuery(
			ProbeListTableVo proListTableVo,Integer pageCount,Integer pageSize,
			Integer sort,String sortDic)
	{
		HashMap<String, Object> map=new HashMap<>();//定义存放SQL所需数据的MAP
		map.put("proListTableVo", proListTableVo);
		map.put("sort", sort==null?null:sort);
		map.put("sortDic", sortDic==null?"DESC":sortDic);
		//设置分页产数
		PageHelper.startPage(pageCount==null||pageSize==null?1:(pageCount/pageSize)+1,pageSize==null?Integer.MAX_VALUE:pageSize);
		//获取没有分页的数据
		List<ProbeListTablePo> poList=probeListDaoI.getProbeListByIdCityIsLink(map);
		//执行分页
		PageInfo<ProbeListTablePo> pageInfo=new PageInfo<>(poList);
		return pageInfo;
		
	}
	/**   
	 <blockquote>
	 <h1>封装任务列表最总返回的数据</h1>
	 * @param poList - 任务列表的数据源
	 * @return
	 * @throws Exception 
	 */
	@Override
	public List<List<String>> getFinalDataIsOperTask(List<ProbeTaskXmlPingJoinPo> poList) throws Exception
	{
		List<List<String>> retList = new ArrayList<>();// 最终返回的List

		for(int i=0,len=poList.size();i<len;i++ ){//遍历得到的数据对象
			ProbeTaskXmlPingJoinPo p=poList.get(i);
			List<String> list = new ArrayList<>();// 临时存放元素的List
			list.add(p.getId()==null?"":p.getId());
			list.add(p.getId()==null?"":p.getId());
			list.add(p.getType_name()==null?"":p.getType_name());
			list.add(p.getHost_ip()==null?"":p.getHost_ip());
			list.add(p.getCreatetime()==null?"":p.getCreatetime());
			list.add(p.getEndtime()==null?"":p.getEndtime());
			//list.add(DateUtil.getDateStrIsMillisecond(Long.parseLong(p.getTest_time()), "yyyy-MM-dd HH:mm:ss"));
			list.add(p.getTest_time()==null?"":p.getTest_time());
			// 将单个的集合添加到总集合中
			retList.add(list);
		}
		return retList;
	}
	/**
	 <blockquote>
	 <h1>获取任务列表的数据源</h1>
	 * @param task_id - 探针ID
	 * @param typeName - 探针类型
	 * @param startTime - 开始时间
	 * @param ip - ip
	 * @return
	 */
	@Override
	@Transactional(readOnly=true,propagation=Propagation.REQUIRED)
	public List<ProbeTaskXmlPingJoinPo> getDataSourceIsOperTask(String task_id, Integer type_id,
			String startTime,String endtime, String ip,Integer sort,String sortDic)
	{
		List<ProbeTaskXmlPingJoinPo> retList=new  ArrayList<>();
		HashMap<String, Object> dataMap=new HashMap<>();
		dataMap.put("task_id", task_id);
		dataMap.put("type_id", type_id);
		dataMap.put("createtime", startTime);
		dataMap.put("endtime", endtime);
		dataMap.put("hostip", ip);
		dataMap.put("sort", sort);
        dataMap.put("sortDic", sortDic==null?"DESC":sortDic);
		retList=probeXmlDaoI.getUnionDataToTaskXmlPing(dataMap);
		return retList;
	}
	/**   
	 <blockquote>
	 <h1>获取分页状态下的任务列表的数据源</h1>
	 * @param task_id
	 * @param typeName
	 * @param startTime
	 * @param ip
	 * @param pageCount - 开始数据
	 * @param pageSize - 每页大小
	 * @param sort - 要排序字段在查询字段中的索引
	 * @param sortDic - 排序方式
	 * @return 
	 */
	@Override
	@Transactional(readOnly=true,propagation=Propagation.REQUIRED)
	public PageInfo<ProbeTaskXmlPingJoinPo> getPageDataSourceIsOperTask(String task_id, Integer type_id,
			String startTime,String endtime, String ip, Integer pageCount, Integer pageSize, Integer sort, String sortDic)
	{
		HashMap<String, Object> dataMap=new HashMap<>();//定义存放SQL所需数据的MAP
		dataMap.put("task_id", task_id);
		dataMap.put("type_id", type_id);
		dataMap.put("createtime", startTime);
		dataMap.put("endtime", endtime);
		dataMap.put("hostip", ip);
		dataMap.put("sort", sort);
		dataMap.put("sortDic", sortDic==null?"DESC":sortDic);
		PageHelper.startPage(pageCount==null||pageSize==null?1:(pageCount/pageSize)+1,pageSize==null?Integer.MAX_VALUE:pageSize,true);
		List<ProbeTaskXmlPingJoinPo> retList=probeXmlDaoI.getUnionDataToTaskXmlPing(dataMap);
		PageInfo<ProbeTaskXmlPingJoinPo> pageInfo=new PageInfo<>(retList);
		return pageInfo;
	}
	
}
